home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / Resources / CutePDF 2.3 / converter.exe / GNUGS / GS_CIDCM.PS < prev    next >
Text File  |  2002-04-03  |  19KB  |  511 lines
  1. %    Copyright (C) 2000 artofcode LLC.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_cidcm.ps,v 1.5.2.2 2002/04/02 13:55:47 mpsuzuki Exp $
  17. % Extending Font resource category with CIDFont-CMap fonts.
  18.  
  19. languagelevel 2 .setlanguagelevel currentglobal true setglobal
  20.  
  21.  
  22. % In the comments below, 'CSI' is an abbreviation/acronym for CIDSystemInfo.
  23. % We pre-scan resource files to retrieve the CSI from them.
  24. % First we define a hidden procset .prs_dict containing
  25. % necessary variables and procedures.
  26. % Then we redefine the old /Font category using this procset.
  27.  
  28. % We maintain internal caches for the CSI values retrieved from
  29. % resource files. This supposes that document doesn't uninstall
  30. % resource files. To disable caching, set enable_cache to false.
  31.  
  32. % We suppose that names starting with '.prs' do not appear in resource files.
  33. % If this causes any problem, this prefix should be systematically changed
  34. % in this file.  ('prs' is an abbreviation for 'prescan'.)
  35.  
  36. 25 dict begin
  37.  
  38. % Define local variables :
  39.  
  40. /.prs_dict currentdict def       % self-reference (constant)
  41. /.prs_empty 0 dict readonly def  
  42. /path_buffer 255 string def
  43. /name_buffer 255 string def
  44. /minus (-) 0 get def             % character code constant for '-'
  45. /period (.) 0 get def            % character code constant for '.'
  46. /CMap 10 dict def                % CSI cache for CMaps
  47. /CIDFont 10 dict def             % CSI cache for CIDFonts
  48. /enable_cache true def           % set false to disable cache
  49.  
  50. % The folloving variables are just placeholders for ones to be set
  51. % dynamically :
  52. /.prsFile 0 def                   % file to prescan
  53. /.prsResult 0 def                 % result of prescan
  54. /.prsDictCount 0 def              % save the dictionary stack depth
  55.  
  56. % Define a dummy CIDInit procset to use while pre-scanning :
  57.  
  58. /DummyCIDInit 15 dict 
  59. begin
  60.  
  61.   /begincmap {} def
  62.   /usecmap {pop} bind def
  63.  
  64.   {stop} bind
  65.   [ /begincodespacerange /endcodespacerange /beginnotdefchar /endnotdefchar
  66.     /beginnotdefrange /endnotdefrange /begincidchar /endcidchar /begincidrange 
  67.     /endcidrange /endcmap /usefont /StartData
  68.   ] {
  69.     1 index def
  70.   } bind forall
  71.   pop
  72.  
  73. currentdict end def
  74.  
  75. % Define a local 'findresource' for pre-scanning :
  76. % (it returns the dummy CIDInit instead of the regular CIDInit ProcSet)
  77.  
  78. /findresource { % <InstName> <CatName> findresource <inst>
  79.   2 copy /ProcSet eq exch             % /InstName /CatName bool /InstName
  80.   /CIDInit eq and {
  81.     pop pop //DummyCIDInit
  82.   } {
  83.     //findresource exec
  84.   } ifelse
  85. } bind def
  86.  
  87. % Define procedures for pre-scanning :
  88.  
  89. /StopIfCSIDefined {   % - StopIfCSIDefined -
  90.   
  91.   % Check if the dictionary stack contains a dictionary containing /CIDSystemInfo. 
  92.   % The search is limited to the top .prsDictCount dictionaries in the stack.
  93.   % If so, retrieve the CSI, and execute stop to terminate the pre-scanning of the file.
  94.   % Otherwise, do nothing, so the pre-scanning continues.
  95.  
  96.   countdictstack //.prs_dict /.prsDictCount get sub dup {
  97.     currentdict /CIDSystemInfo .knownget {
  98.       //.prs_dict exch /.prsResult exch put
  99.       stop
  100.     } if
  101.     currentdict exch end
  102.   } repeat {
  103.     begin
  104.   } repeat
  105. } bind def
  106.  
  107. /PrescanFile {     % - PrescanFile -
  108.   { //.prs_dict /.prsFile get token {      
  109.       dup type                          % token type
  110.       dup /nametype eq exch /operatortype eq or {
  111.         dup xcheck {
  112.           exec
  113.           //StopIfCSIDefined exec
  114.         } if
  115.       } if
  116.     } {
  117.       stop
  118.     } ifelse
  119.   } loop
  120. } bind odef
  121.  
  122. /GetCIDSystemInfoFromFile { % <file> GetCIDSystemInfoFromFile <CSI>
  123.   
  124.   % This procedure reads resource files with 'token',
  125.   % executing the tokens untill /CIDSystemInfo appears to be defined.
  126.   % Normally the resource file creates a new dictionary on
  127.   % dictionary stack and defines /CIDSystemInfo in it.
  128.   %
  129.   % Returns an empty dictionary if no CIDSystemInfo is found.
  130.  
  131.   //.prs_dict begin
  132.   /.prsFile exch def
  133.   /.prsResult //.prs_empty def
  134.   /.prsDictCount countdictstack def
  135.   { //PrescanFile } stopped pop
  136.   //.prs_dict /.prsResult get
  137.   end
  138. } bind def
  139.  
  140. /GetCIDSystemInfo {     % <InstName> <CatName> GetCIDSystemInfo <CSI>
  141.   
  142.   % Retrieve CSI, using caches.
  143.   
  144.   2 copy resourcestatus {
  145.     pop 2 lt {
  146.       findresource /CIDSystemInfo .knownget not {
  147.         //.prs_empty
  148.       } if
  149.     } {                                                      
  150.       dup //.prs_dict exch get                % /InstName /CatName CSIs
  151.       dup 3 index known
  152.       //enable_cache and {                            
  153.         exch pop exch get                     % CSI
  154.       } {                                                  
  155.         3 1 roll                              % CSIs /InstName /CatName
  156.         /Category findresource begin          % CSIs /InstName
  157.         dup //path_buffer ResourceFileName    % CSIs /InstName (path)
  158.         end                                   
  159.         currentglobal exch true setglobal     % CSIs /InstName g
  160.         mark exch                             % CSIs /InstName g [ (path)
  161.         { (r) file                            % CSIs /InstName g [ file
  162.           //GetCIDSystemInfoFromFile exec     % CSIs /InstName g [ CSI
  163.         } stopped {
  164.       % Cannot find file from Resource directory
  165.           cleartomark
  166.       % Try to find file from CIDFontmap
  167.       % Stack: CSIs /InstName g
  168.       1 index dup .CIDFontmapKnownget {
  169.           % Stack: CSIs /InstName g /InstName ValueInCIDFontmap
  170.           % We do look at CIDFontmap in global space.
  171.           % (When stopped, the space is set to local.)
  172.           true setglobal
  173.           1 index 3 1 roll
  174.           .CIDFontmapRunHandler
  175.           /CIDFont findresource /CIDSystemInfo get
  176.       } {
  177.           pop //.prs_empty             
  178.       } ifelse
  179.         } {
  180.           exch pop
  181.         } ifelse                              % CSIs /InstName g CSI
  182.         exch setglobal                        % CSIs /InstName CSI
  183.         dup 4 1 roll                          % CSI CSIs /InstName CSI
  184.         put                                   % CSI
  185.       } ifelse
  186.     } ifelse
  187.   } {
  188.     pop pop //.prs_empty
  189.   } ifelse
  190. } bind def
  191.  
  192. /IsCompatibleCSI {  % <CSI-M> <CSI-F> IsCompatibleCSI <bool>
  193.   
  194.   % The CSI in a CIDFont may be an array, a dict, or null.
  195.   % If it is an array, it must be of 1 element, which is a dict.
  196.   % In this case the dict is used for testing the compatibility.
  197.   % Two dicts are compatible iff they contain same /Ordering and /Registry.
  198.  
  199.   exch                                  % CSI-F CSI-M
  200.   { dup type /arraytype eq {
  201.       dup length 1 ne {
  202.         pop pop false exit
  203.       } if
  204.       0 get
  205.     } if                                % CSI-F CSI-M
  206.     dup type /dicttype ne {
  207.       pop pop false exit
  208.     } if                                % CSI-F <<CSI-M>>
  209.     exch                                % <<CSI-M>> CSI-F
  210.     dup type /dicttype ne {
  211.       pop pop false exit
  212.     } if                                % <<CSI-M>> <<CSI-F>>
  213.     true                                % <<CSI-M>> <<CSI-F>> bEQ
  214.     [/Registry /Ordering] {                    
  215.       2 index 1 index .knownget not {
  216.         1234567
  217.       } if                              % <<CSI-M>> <<CSI-F>> bEQ /key vF
  218.       exch                              % <<CSI-M>> <<CSI-F>> bEQ vF /key
  219.       4 index exch .knownget not {
  220.         7654321
  221.       } if                              % <<CSI-M>> <<CSI-F>> bEQ vF vM
  222.       eq and                            % <<CSI-M>> <<CSI-F>> bEQ
  223.     } forall
  224.     exch pop exch pop                   % bEQ
  225.     exit
  226.   } loop
  227. } bind def
  228.  
  229. /IsComposedOK {     % <CIDFontName> <CMapName> IsComposedOK <bool>
  230.   
  231.   % Check if the given CIDFont and CMap have compatible CSIs.
  232.  
  233.   exch                                  % /CMapName /CIDFontName
  234.   /CIDFont //GetCIDSystemInfo exec      % /CMapName CSI-F
  235.   dup type /dicttype eq {
  236.     dup length 0 ne {                          
  237.       exch                              % CSI-F /CMapName
  238.       /CMap //GetCIDSystemInfo exec     % CSI-F CSI-M
  239.       //IsCompatibleCSI exec            % bool
  240.     } {
  241.       pop pop false
  242.     } ifelse
  243.   } {
  244.     pop pop false
  245.   } ifelse
  246. } bind def
  247.  
  248. /IsComposedFont {   % <FontName> IsComposedFont <CIDFontName> <CMapName> true
  249.                     % <FontName> IsComposedFont false
  250.   
  251.   % Check if the given font name may be decomposed into CIDFont.CMap, CIDFont-CMap
  252.   % or into CIDFont--CMap, such that CIDFont and CMap have compatible CSIs.
  253.                                         % FontName
  254.   dup type /stringtype ne {
  255.     //name_buffer cvs
  256.   } if                                  % (FontName)
  257.   { dup length 2 sub -1 1 {
  258.                                         % (FontName) i
  259.       2 copy get dup //minus eq exch //period eq or {                
  260.         2 copy 2 copy                   % (FontName) i (FontName) i (FontName) i
  261.         2 copy get //minus eq {
  262.           2 copy 1 sub get //minus eq {
  263.             1 sub
  264.           } if
  265.         } if                            % (FontName) i (FontName) i (FontName) i0
  266.         0 exch getinterval cvn          % (FontName) i (FontName) i /CIDFontName
  267.         3 1 roll                        % (FontName) i /CIDFontName (FontName) i
  268.         1 add dup                       % (FontName) i /CIDFontName (FontName) i1 i1
  269.         5 index length                  % (FontName) i /CIDFontName (FontName) i1 i1 l
  270.         exch sub getinterval cvn        % (FontName) i /CIDFontName /CMapName
  271.         2 copy //IsComposedOK exec {    % (FontName) i /CIDFontName /CMapName 
  272.           4 2 roll pop pop              % /CIDFontName /CMapName
  273.           stop
  274.         } if
  275.         pop pop pop
  276.       } {
  277.         pop
  278.       } ifelse                          % (FontName)
  279.     } for
  280.     pop
  281.   } stopped
  282. } bind def
  283.  
  284. /ComposeName { % <CIDFont> <CMap> <scr> ComposeName <CIDFont-CMap>
  285.   dup dup 5 2 roll                        % (scr) (scr) /CIDFont /CMap (scr)
  286.   3 2 roll exch cvs length dup            % (scr) (scr) /CMap l0 l0
  287.   4 -1 roll exch //minus put              % (scr) /CMap l0
  288.   1 add dup                               % (scr) /CMap l1 l1
  289.   3 index dup length                      % (scr) /CMap l1 l1 (scr) L
  290.   2 index sub                             % (scr) /CMap l1 l1 (scr) LT
  291.   3 2 roll                                % (scr) /CMap l1 (scr) LT l1
  292.   exch getinterval                        % (scr) /CMap l1 (scrT)
  293.   3 2 roll exch cvs length                % (scr) l1 l2
  294.   add 0 exch getinterval                  % (CIDFont-CMap)
  295. } bind def
  296.  
  297.  
  298. % Define a few procedure templates to be modified dynamically :
  299.  
  300. currentpacking false setpacking
  301.  
  302. /BindAux {   % <proc> BindAux <proc>
  303.   0 exec
  304. } bind def
  305.  
  306. /EnumerateFontNames { %  - EnumerateFontNames ...
  307.   
  308.   % This is a pattern for enumeration procedure to be built dynamically,
  309.   % using Bind with a temporary dictionary.
  310.   % The following names will be replaced with specific objects
  311.   % during Bind : en_local_dict, scr, proc, Fonts, Category .
  312.  
  313.   end % Category
  314.   { 
  315.     0 1 2 {
  316.       en_local_dict exch /status exch put
  317.       Fonts {                                            
  318.         en_local_dict /status get eq {            
  319.           scr cvs                           % ... (Font)
  320.           proc exec                         %
  321.         } {
  322.           pop
  323.         } ifelse                            % ...
  324.       } forall
  325.     } for                                   % ...
  326.   } stopped
  327.   Category begin
  328.   { stop } if
  329. } bind def
  330.  
  331. setpacking
  332.  
  333. /Bind {    % <proc> Bind <proc>
  334.   
  335.   % Make a copy of the given procedure, binding in the values of all names
  336.   % defined in currentdict.
  337.   % Caution : this code cannot handle procedures that were already
  338.   % bound recursively.
  339.  
  340.   dup length array copy
  341.   dup length 1 sub -1 0 {                      
  342.     2 copy get                            % {precopy} i {elem}
  343.     dup dup type /arraytype eq exch xcheck and {
  344.                                           % {precopy} i {elem}
  345.       //BindAux exec                      % {precopy} i {elem_copy}
  346.       2 index 3 1 roll put                % {precopy}
  347.     } {
  348.       dup dup type /nametype eq exch xcheck and {
  349.                                           % {precopy} i {elem}
  350.         currentdict exch .knownget {            
  351.           2 index 3 1 roll put            % {precopy}
  352.         } {                                            
  353.           pop
  354.         } ifelse
  355.       } {
  356.         pop pop
  357.       } ifelse
  358.     } ifelse                              % {precopy}
  359.   } for                                   % {copy}
  360.   cvx
  361. } bind def
  362.  
  363. //BindAux 0 //Bind put   % bind the recursive call in 'Bind'.
  364.  
  365.  
  366.  
  367. % Redefine the /Font category with CIDFont-CMap construction :
  368.  
  369. % The following code supposes that the following names are not
  370. % defined in the old /Font category dictionary :
  371. % /IsComposedFont, /Bind, /IsComposedOK, /EnumerateFontNames .
  372.  
  373.  
  374. /Font /Category findresource dup length dict copy begin
  375.  
  376. /FindResource {  % <InstName> FindResource <inst>
  377.   dup //ResourceStatus exec {
  378.     pop pop //FindResource exec
  379.   } {                                                
  380.     dup //IsComposedFont exec {          % /FontName /CIDFontName /CMapName 
  381.       exch [ exch ] composefont          % inst
  382.     } {
  383.       //FindResource exec
  384.     } ifelse
  385.   } ifelse
  386. } bind def
  387.  
  388. /ResourceStatus {  % <InstName> ResourceStatus <nStatus> <nSize> true
  389.                    % <InstName> ResourceStatus false
  390.   dup //ResourceStatus exec {                    
  391.     3 2 roll pop true                     % nStatus nSize true
  392.   } {                                                  
  393.     //IsComposedFont exec {               % /CIDFontName /CMapName 
  394.       /CMap resourcestatus {              % /CIDFontName nStatusM nSizeM 
  395.         exch pop exch                     % nSizeM /CIDFontName 
  396.         /CIDFont resourcestatus {         % nSizeM nStatusF nSizeF 
  397.           exch pop                        % nSizeF nSizeM
  398.           dup 0 ge {
  399.             exch dup 0 ge {
  400.               add
  401.             } {
  402.               exch pop
  403.             } ifelse
  404.           } {
  405.             pop
  406.           } ifelse                        % nSize
  407.           2 exch true                     % nStatus nSize true
  408.         } {                        
  409.           pop pop pop false  % work around buggy resource file
  410.         } ifelse
  411.       } {                            
  412.         pop pop pop false    % work around buggy resource file
  413.       } ifelse
  414.     } {
  415.       false
  416.     } ifelse
  417.   } ifelse
  418. } bind def
  419.  
  420. /ResourceForAll { % <template> <proc> <scratch> ResourceForAll - 
  421.  
  422.   % We suppose that the resourceforall procedure does not 
  423.   % define or install new fonts, CMaps, and/or CIDFonts.
  424.  
  425.   % First we create 3 temporary dictionaries to store temporary data
  426.   % about fonts, CMaps and CIDFonts.
  427.   % These dictionaries must be created dynamically, to allow for a possible 
  428.   % recursive call to resourceforall from the resourceforall procedure.
  429.  
  430.   currentglobal false setglobal
  431.   20 dict 20 dict 20 dict
  432.   4 -1 roll setglobal                     % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  433.  
  434.   % Store resource names into local dictionaries :
  435.  
  436.   5 index [ 2 index {exch cvn dup put} aload pop ] cvx 5 index //ResourceForAll exec
  437.   (*)     [ 3 index {exch cvn dup put} aload pop ] cvx 5 index /CMap resourceforall
  438.   (*)     [ 4 index {exch cvn dup put} aload pop ] cvx 5 index /CIDFont resourceforall
  439.  
  440.   %% Make the list of fonts in the form (/Name status) :
  441.  
  442.                                           % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  443.   dup {                                              
  444.     //ResourceStatus exec {                        
  445.       pop 2 index                         % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>> /Name nStatus <<Font>>
  446.       3 1 roll put                        % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  447.     } {
  448.       pop
  449.     } ifelse
  450.   } forall                                % (templ) proc (scr) <<CIDFont>> <<CMap>> <<Fonts>>
  451.  
  452.   %% Add CIDFont-CMap to it (filtering duplicates) :
  453.  
  454.   3 2 roll  {                                        
  455.     3 index {                                        
  456.       3 1 roll                            % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /CIDFont /CMap
  457.       6 index //ComposeName exec          % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap (Font)
  458.       dup 8 index .stringmatch {              
  459.         cvn                               % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /Font
  460.         dup 4 index exch known {
  461.           pop pop
  462.         } {                                            
  463.           2 index                         % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CMap /Font /CIDFont
  464.           4 2 roll                        % (templ) proc (scr) <<CMap>> <<Font>> /Font /CIDFont /CIDFont /CMap
  465.           //IsComposedOK exec {                
  466.             exch 2 index exch 2 put       % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont
  467.           } {
  468.             exch pop
  469.           } ifelse
  470.         } ifelse
  471.       } {
  472.         pop pop
  473.       } ifelse
  474.       dup                                 % (templ) proc (scr) <<CMap>> <<Font>> /CIDFont /CIDFont
  475.     } forall
  476.     pop pop                               % (templ) proc (scr) <<CMap>> <<Font>>
  477.   } forall                                % (templ) proc (scr) <<CMap>> <<Font>>
  478.   exch pop                                % (templ) proc (scr) <<Font>>
  479.  
  480.   % Build the enumeration procedure :
  481.  
  482.   % Since the resourceforall procedure may leave values on the operand stack,
  483.   % we cannot simply store the enumerator's local data on the stack.
  484.   % We also cannot use a static dictionary to store local variables,
  485.   % because of possible recursion in the resourceforall procedure.
  486.   % To work around this, we create a copy of the enumeration procedure and
  487.   % bind it dynamically with a temporary dictionary, which contains
  488.   % local variables for the currently executing instance of resourceforall.
  489.  
  490.   currentdict
  491.   6 dict begin % the temporary dictionary
  492.     /Category exch def
  493.     /Fonts exch def
  494.     /scr exch def
  495.     /proc exch def
  496.     /en_local_dict currentdict def
  497.     //EnumerateFontNames //Bind exec      % (templ) Enumerator
  498.     /status 0 def % variable for the current status to enumerate - do not Bind with it !
  499.   end
  500.   exch pop                                % Enumerator
  501.  
  502.   % Do the enumeration :
  503.  
  504.   exec
  505. } bind def
  506.  
  507.  
  508. currentdict end /Font exch /Category defineresource pop
  509. end
  510. setglobal .setlanguagelevel
  511.